{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "24281003",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torchvision import datasets,transforms\n",
    "import time\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1135f31",
   "metadata": {},
   "source": [
    "# GoogLeNet InceptionV3 的 PyTorch 复现（猫狗大战）"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ad4aaa3",
   "metadata": {},
   "source": [
    "## 1. 数据集制作"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e58ad51",
   "metadata": {},
   "source": [
    "在论文中作者使用的是ILSVRC 2012比赛数据集，该数据集非常大（有138G），下载、训练都很消耗时间，我们在复现的时候就不用这个数据集了。由于MNIST、CIFAR10、CIFAR100这些数据集图片尺寸都较小，不符合GoogLeNet网络输入尺寸227x227的要求，因此我们改用kaggle比赛经典的“猫狗大战”数据集了。\n",
    "\n",
    "该数据集包含的训练集总共25000张图片，猫狗各12500张，带标签；测试集总共12500张，不带标签。我们仅使用带标签的25000张图片，分别拿出2500张猫和狗的图片作为模型的验证集。我们按照以下目录层级结构，将数据集图片放好。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14c776ef",
   "metadata": {},
   "source": [
    "![](./images/path.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ddc3248",
   "metadata": {},
   "source": [
    "为了方便大家训练，我们将该数据集放在百度云盘，下载链接： 链接：https://pan.baidu.com/s/1UEOzxWWMLCUoLTxdWUkB4A 提取码：cdue"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f9e991a",
   "metadata": {},
   "source": [
    "### 1.1 制作图片数据的索引"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff423b68",
   "metadata": {},
   "source": [
    "准备好数据集之后，我们需要用PyTorch来读取并制作可以用来训练和测试的数据集。对于训练集和测试集，首先要分别制作对应的图片数据索引，即train.txt和test.txt两个文件，每个txt中包含每个图片的目录和对应类别class（cat对应的label=0，dog对应的label=1）。示意图如下："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9355c03",
   "metadata": {},
   "source": [
    "![](./images/index.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b9f254c",
   "metadata": {},
   "source": [
    "制作图片数据索引train.txt和test.txt两个文件的python脚本程序如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "57c49926",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "train_txt_path = os.path.join(\"data\", \"catVSdog\", \"train.txt\")\n",
    "train_dir = os.path.join(\"data\", \"catVSdog\", \"train_data\")\n",
    "valid_txt_path = os.path.join(\"data\", \"catVSdog\", \"test.txt\")\n",
    "valid_dir = os.path.join(\"data\", \"catVSdog\", \"test_data\")\n",
    "\n",
    "def gen_txt(txt_path, img_dir):\n",
    "    f = open(txt_path, 'w')\n",
    "    \n",
    "    for root, s_dirs, _ in os.walk(img_dir, topdown=True):  # 获取 train文件下各文件夹名称\n",
    "        for sub_dir in s_dirs:\n",
    "            i_dir = os.path.join(root, sub_dir)             # 获取各类的文件夹 绝对路径\n",
    "            img_list = os.listdir(i_dir)                    # 获取类别文件夹下所有png图片的路径\n",
    "            for i in range(len(img_list)):\n",
    "                if not img_list[i].endswith('jpg'):         # 若不是png文件，跳过\n",
    "                    continue\n",
    "                #label = (img_list[i].split('.')[0] == 'cat')? 0 : 1 \n",
    "                label = img_list[i].split('.')[0]\n",
    "                # 将字符类别转为整型类型表示\n",
    "                if label == 'cat':\n",
    "                    label = '0'\n",
    "                else:\n",
    "                    label = '1'\n",
    "                img_path = os.path.join(i_dir, img_list[i])\n",
    "                line = img_path + ' ' + label + '\\n'\n",
    "                f.write(line)\n",
    "    f.close()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    gen_txt(train_txt_path, train_dir)\n",
    "    gen_txt(valid_txt_path, valid_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8018fb3f",
   "metadata": {},
   "source": [
    "运行脚本之后就在./data/catVSdog/目录下生成train.txt和test.txt两个索引文件。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40313c95",
   "metadata": {},
   "source": [
    "### 1.2 构建Dataset子类"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07a76b2f",
   "metadata": {},
   "source": [
    "PyTorch 加载自己的数据集，需要写一个继承自torch.utils.data中Dataset类，并修改其中的__init__方法、__getitem__方法、__len__方法。默认加载的都是图片，__init__的目的是得到一个包含数据和标签的list，每个元素能找到图片位置和其对应标签。然后用__getitem__方法得到每个元素的图像像素矩阵和标签，返回img和label。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "6659ac30",
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "from torch.utils.data import Dataset\n",
    "\n",
    "class MyDataset(Dataset):\n",
    "    def __init__(self, txt_path, transform = None, target_transform = None):\n",
    "        fh = open(txt_path, 'r')\n",
    "        imgs = []\n",
    "        for line in fh:\n",
    "            line = line.rstrip()\n",
    "            words = line.split()\n",
    "            imgs.append((words[0], int(words[1]))) # 类别转为整型int\n",
    "            self.imgs = imgs \n",
    "            self.transform = transform\n",
    "            self.target_transform = target_transform\n",
    "    def __getitem__(self, index):\n",
    "        fn, label = self.imgs[index]\n",
    "        img = Image.open(fn).convert('RGB') \n",
    "        #img = Image.open(fn)\n",
    "        if self.transform is not None:\n",
    "            img = self.transform(img) \n",
    "        return img, label\n",
    "    def __len__(self):\n",
    "        return len(self.imgs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06c03ece",
   "metadata": {},
   "source": [
    "getitem是核心函数。self.imgs是一个list，self.imgs[index]是一个str，包含图片路径，图片标签，这些信息是从上面生成的txt文件中读取；利用Image.open对图片进行读取，注意这里的img是单通道还是三通道的；self.transform(img)对图片进行处理，这个transform里边可以实现减均值、除标准差、随机裁剪、旋转、翻转、放射变换等操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9dfc6b2",
   "metadata": {},
   "source": [
    "### 1.3 加载数据集和数据预处理"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbdfd0b6",
   "metadata": {},
   "source": [
    "当Mydataset构建好，剩下的操作就交给DataLoder来加载数据集。在DataLoder中，会触发Mydataset中的getiterm函数读取一张图片的数据和标签，并拼接成一个batch返回，作为模型真正的输入。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "b12fda3d",
   "metadata": {},
   "outputs": [],
   "source": [
    "pipline_train = transforms.Compose([\n",
    "    #transforms.RandomResizedCrop(224),\n",
    "    transforms.RandomHorizontalFlip(),  #随机旋转图片\n",
    "    #将图片尺寸resize到299x299\n",
    "    transforms.Resize((299,299)),\n",
    "    #将图片转化为Tensor格式\n",
    "    transforms.ToTensor(),\n",
    "    #正则化(当模型出现过拟合的情况时，用来降低模型的复杂度)\n",
    "    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
    "    #transforms.Normalize(mean = [0.485, 0.456, 0.406],std = [0.229, 0.224, 0.225])\n",
    "])\n",
    "pipline_test = transforms.Compose([\n",
    "    #将图片尺寸resize到299x299\n",
    "    transforms.Resize((299,299)),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
    "    #transforms.Normalize(mean = [0.485, 0.456, 0.406],std = [0.229, 0.224, 0.225])\n",
    "])\n",
    "train_data = MyDataset('./data/catVSdog/train.txt', transform=pipline_train)\n",
    "test_data = MyDataset('./data/catVSdog/test.txt', transform=pipline_test)\n",
    "\n",
    "#train_data 和test_data包含多有的训练与测试数据，调用DataLoader批量加载\n",
    "trainloader = torch.utils.data.DataLoader(dataset=train_data, batch_size=64, shuffle=True)\n",
    "testloader = torch.utils.data.DataLoader(dataset=test_data, batch_size=32, shuffle=False)\n",
    "# 类别信息也是需要我们给定的\n",
    "classes = ('cat', 'dog') # 对应label=0，label=1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "088dbdf9",
   "metadata": {},
   "source": [
    "InceptionV3 要求的输入图片尺寸是299x299。在数据预处理中，我们将图片尺寸调整到299x299，符合VGGNet网络的输入要求。均值mean = [0.5, 0.5, 0.5]，方差std = [0.5, 0.5, 0.5]，然后使用transforms.Normalize进行归一化操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "849aac26",
   "metadata": {},
   "source": [
    "我们来看一下最终制作的数据集图片和它们对应的标签："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "ffa411f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "examples = enumerate(trainloader)\n",
    "batch_idx, (example_data, example_label) = next(examples)\n",
    "# 批量展示图片\n",
    "for i in range(4):\n",
    "    plt.subplot(1, 4, i + 1)\n",
    "    plt.tight_layout()  #自动调整子图参数，使之填充整个图像区域\n",
    "    img = example_data[i]\n",
    "    img = img.numpy() # FloatTensor转为ndarray\n",
    "    img = np.transpose(img, (1,2,0)) # 把channel那一维放到最后\n",
    "    img = img * [0.5, 0.5, 0.5] + [0.5, 0.5, 0.5]\n",
    "    #img = img * [0.229, 0.224, 0.225] + [0.485, 0.456, 0.406]\n",
    "    plt.imshow(img)\n",
    "    plt.title(\"label:{}\".format(example_label[i]))\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bd34148",
   "metadata": {},
   "source": [
    "## 2. 搭建 GoogLeNet InceptionV3 神经网络结构"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f441d6f6",
   "metadata": {},
   "source": [
    "源码部分 Inception V3 与论文中介绍的不完全一样，我们使用 PyTorch 复现的 Inception V3 结构如下图所示："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfd9584d",
   "metadata": {},
   "source": [
    "首先定义基本的 2d 卷积类，加入了 Batch Normalization，ReLU6是在ReLU的基础上，限制正值的上限6。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "44227606",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BasicConv2d(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels, **kwargs):\n",
    "        super(BasicConv2d, self).__init__()\n",
    "        self.conv = nn.Conv2d(in_channels, out_channels, **kwargs)\n",
    "        self.relu = nn.ReLU6(inplace=True)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.conv(x)\n",
    "        x = self.relu(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "bc657feb",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvBNReLU(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels, **kwargs):\n",
    "        super(ConvBNReLU, self).__init__()\n",
    "        self.conv = nn.Conv2d(in_channels, out_channels, **kwargs)\n",
    "        self.bn = nn.BatchNorm2d(out_channels)\n",
    "        self.relu = nn.ReLU6(inplace=True)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.conv(x)\n",
    "        x = self.bn(x)\n",
    "        x = self.relu(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e684e166",
   "metadata": {},
   "source": [
    "InceptionV3_A 模块结构："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a91dba73",
   "metadata": {},
   "source": [
    "![](./images/inceptionV3_A.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "453e4209",
   "metadata": {},
   "outputs": [],
   "source": [
    "class InceptionV3_A(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels_1, out_channels_2red, out_channels_2, out_channels_3red, out_channels_3, out_channels_4):\n",
    "        super(InceptionV3_A, self).__init__()\n",
    "\n",
    "        self.branch1 = ConvBNReLU(in_channels, out_channels_1, kernel_size=1)\n",
    "\n",
    "        self.branch2 = nn.Sequential(\n",
    "            ConvBNReLU(in_channels, out_channels_2red, kernel_size=1),\n",
    "            ConvBNReLU(out_channels_2red, out_channels_2, kernel_size=5, padding=2)   # 保证输出大小等于输入大小\n",
    "        )\n",
    "\n",
    "        self.branch3 = nn.Sequential(\n",
    "            ConvBNReLU(in_channels, out_channels_3red, kernel_size=1),\n",
    "            ConvBNReLU(out_channels_3red, out_channels_3, kernel_size=3, padding=1),   # 保证输出大小等于输入大小\n",
    "            ConvBNReLU(out_channels_3, out_channels_3, kernel_size=3, padding=1)   # 保证输出大小等于输入大小\n",
    "        )\n",
    "\n",
    "        self.branch4 = nn.Sequential(\n",
    "            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),\n",
    "            ConvBNReLU(in_channels, out_channels_4, kernel_size=1)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        branch1 = self.branch1(x)\n",
    "        branch2 = self.branch2(x)\n",
    "        branch3 = self.branch3(x)\n",
    "        branch4 = self.branch4(x)\n",
    "\n",
    "        outputs = [branch1, branch2, branch3, branch4]\n",
    "        return torch.cat(outputs, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18748bb9",
   "metadata": {},
   "source": [
    "InceptionV3_B 模块结构："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bd1eb3d",
   "metadata": {},
   "source": [
    "![](./images/inceptionV3_B.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "ab4178bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "class InceptionV3_B(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels_1, out_channels_2red, out_channels_2, out_channels_3red, out_channels_3, out_channels_4):\n",
    "        super(InceptionV3_B, self).__init__()\n",
    "\n",
    "        self.branch1 = ConvBNReLU(in_channels, out_channels_1, kernel_size=1)\n",
    "\n",
    "        self.branch2 = nn.Sequential(\n",
    "            ConvBNReLU(in_channels, out_channels_2red, kernel_size=1),\n",
    "            ConvBNReLU(out_channels_2red, out_channels_2red, kernel_size=[1,7], padding=[0,3]),\n",
    "            ConvBNReLU(out_channels_2red, out_channels_2, kernel_size=[7,1], padding=[3,0])\n",
    "        )\n",
    "\n",
    "        self.branch3 = nn.Sequential(\n",
    "            ConvBNReLU(in_channels, out_channels_3red, kernel_size=1),\n",
    "            ConvBNReLU(out_channels_3red, out_channels_3red, kernel_size=[1,7], padding=[0,3]), \n",
    "            ConvBNReLU(out_channels_3red, out_channels_3red, kernel_size=[7,1], padding=[3,0]), \n",
    "            ConvBNReLU(out_channels_3red, out_channels_3red, kernel_size=[1,7], padding=[0,3]), \n",
    "            ConvBNReLU(out_channels_3red, out_channels_3, kernel_size=[7,1], padding=[3,0])\n",
    "        )\n",
    "\n",
    "        self.branch4 = nn.Sequential(\n",
    "            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),\n",
    "            ConvBNReLU(in_channels, out_channels_4, kernel_size=1)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        branch1 = self.branch1(x)\n",
    "        branch2 = self.branch2(x)\n",
    "        branch3 = self.branch3(x)\n",
    "        branch4 = self.branch4(x)\n",
    "\n",
    "        outputs = [branch1, branch2, branch3, branch4]\n",
    "        return torch.cat(outputs, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "600026f1",
   "metadata": {},
   "source": [
    "InceptionV3_C 模块结构："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edff76d0",
   "metadata": {},
   "source": [
    "![](./images/inceptionV3_C.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "2f43e14b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class InceptionV3_C(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels_1, out_channels_2red, out_channels_2, out_channels_3red, out_channels_3, out_channels_4):\n",
    "        super(InceptionV3_C, self).__init__()\n",
    "\n",
    "        self.branch1 = ConvBNReLU(in_channels, out_channels_1, kernel_size=1)\n",
    "        \n",
    "        self.branch2_conv1x1 = ConvBNReLU(in_channels, out_channels_2red, kernel_size=1)\n",
    "        self.branch2_conv1x3 = ConvBNReLU(out_channels_2red, out_channels_2, kernel_size=[1,3],padding=[0,1])\n",
    "        self.branch2_conv3x1 = ConvBNReLU(out_channels_2red, out_channels_2, kernel_size=[3,1],padding=[1,0])\n",
    "        \n",
    "        self.branch3_conv1x1 = ConvBNReLU(in_channels, out_channels_3red, kernel_size=1)\n",
    "        self.branch3_conv3x3 = ConvBNReLU(out_channels_3red, out_channels_3, kernel_size=3,padding=1)\n",
    "        self.branch3_conv3x1 = ConvBNReLU(out_channels_3, out_channels_3, kernel_size=[3,1],padding=[1,0])\n",
    "        self.branch3_conv1x3 = ConvBNReLU(out_channels_3, out_channels_3, kernel_size=[1,3],padding=[0,1])\n",
    "\n",
    "        self.branch4 = nn.Sequential(\n",
    "            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),\n",
    "            ConvBNReLU(in_channels, out_channels_4, kernel_size=1)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        branch1 = self.branch1(x)\n",
    "        branch2_tmp = self.branch2_conv1x1(x)\n",
    "        branch2 = torch.cat([self.branch2_conv1x3(branch2_tmp), self.branch2_conv3x1(branch2_tmp)], dim=1)\n",
    "        branch3_tmp = self.branch3_conv1x1(x)\n",
    "        branch3_tmp = self.branch3_conv3x3(branch3_tmp)\n",
    "        branch3 = torch.cat([self.branch3_conv3x1(branch3_tmp), self.branch3_conv1x3(branch3_tmp)], dim=1)\n",
    "        branch4 = self.branch4(x)\n",
    "\n",
    "        outputs = [branch1, branch2, branch3, branch4]\n",
    "        return torch.cat(outputs, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "720f4a04",
   "metadata": {},
   "source": [
    "InceptionV3_D 模块结构："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93ab6ad8",
   "metadata": {},
   "source": [
    "![](./images/inceptionV3_D.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "d36b1217",
   "metadata": {},
   "outputs": [],
   "source": [
    "class InceptionV3_D(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels_1red, out_channels_1, out_channels_2red, out_channels_2):\n",
    "        super(InceptionV3_D, self).__init__()\n",
    "\n",
    "        self.branch1 = nn.Sequential(\n",
    "            ConvBNReLU(in_channels, out_channels_1red, kernel_size=1),\n",
    "            ConvBNReLU(out_channels_1red, out_channels_1, kernel_size=3, stride=2)   \n",
    "        )\n",
    "\n",
    "        self.branch2 = nn.Sequential(\n",
    "            ConvBNReLU(in_channels, out_channels_2red, kernel_size=1),\n",
    "            ConvBNReLU(out_channels_2red, out_channels_2, kernel_size=3, stride=1, padding=1),  \n",
    "            ConvBNReLU(out_channels_2, out_channels_2, kernel_size=3, stride=2) \n",
    "        )\n",
    "\n",
    "        self.branch3 = nn.MaxPool2d(kernel_size=3, stride=2)\n",
    "\n",
    "    def forward(self, x):\n",
    "        branch1 = self.branch1(x)\n",
    "        branch2 = self.branch2(x)\n",
    "        branch3 = self.branch3(x)\n",
    "\n",
    "        outputs = [branch1, branch2, branch3]\n",
    "        return torch.cat(outputs, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0aa0959",
   "metadata": {},
   "source": [
    "InceptionV3_E 模块结构："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edf2939a",
   "metadata": {},
   "source": [
    "![](./images/inceptionV3_E.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "476e7ab7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class InceptionV3_E(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels_1red, out_channels_1, out_channels_2red, out_channels_2):\n",
    "        super(InceptionV3_E, self).__init__()\n",
    "\n",
    "        self.branch1 = nn.Sequential(\n",
    "            ConvBNReLU(in_channels, out_channels_1red, kernel_size=1),\n",
    "            ConvBNReLU(out_channels_1red, out_channels_1, kernel_size=3, stride=2)   \n",
    "        )\n",
    "\n",
    "        self.branch2 = nn.Sequential(\n",
    "            ConvBNReLU(in_channels, out_channels_2red, kernel_size=1),\n",
    "            ConvBNReLU(out_channels_2red, out_channels_2red, kernel_size=[1, 7], padding=[0, 3]),  \n",
    "            ConvBNReLU(out_channels_2red, out_channels_2red, kernel_size=[7, 1], padding=[3, 0]),\n",
    "            ConvBNReLU(out_channels_2red, out_channels_2, kernel_size=3, stride=2)\n",
    "        )\n",
    "\n",
    "        self.branch3 = nn.MaxPool2d(kernel_size=3, stride=2)\n",
    "\n",
    "    def forward(self, x):\n",
    "        branch1 = self.branch1(x)\n",
    "        branch2 = self.branch2(x)\n",
    "        branch3 = self.branch3(x)\n",
    "\n",
    "        outputs = [branch1, branch2, branch3]\n",
    "        return torch.cat(outputs, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cc74154",
   "metadata": {},
   "source": [
    "定义辅助分类器："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "066efd7b",
   "metadata": {},
   "source": [
    "结构：Pool——>1x1Conv——>5x5Conv——>FC——>softmax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "29991ea2",
   "metadata": {},
   "outputs": [],
   "source": [
    "class InceptionAux(nn.Module):\n",
    "    def __init__(self, in_channels, num_classes):\n",
    "        super(InceptionAux, self).__init__()\n",
    "        self.averagePool = nn.AvgPool2d(kernel_size=5, stride=3)\n",
    "        self.conv1 = ConvBNReLU(in_channels, 128, kernel_size=1)  # output[batch, 128, 4, 4]\n",
    "        self.conv2 = ConvBNReLU(128, 768, kernel_size=5)  # output[batch, 128, 4, 4]\n",
    "        self.fc = nn.Linear(768, num_classes)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.averagePool(x)\n",
    "        x = self.conv1(x)\n",
    "        x = self.conv2(x)\n",
    "        x = torch.flatten(x, 1)\n",
    "        x = F.dropout(x, 0.7, training=self.training)\n",
    "        x = self.fc(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9513a82d",
   "metadata": {},
   "source": [
    "完整的 GoogLeNetV3 网络结构："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a485cadb",
   "metadata": {},
   "source": [
    "![](./images/googlenet_v3.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "33b4b305",
   "metadata": {},
   "outputs": [],
   "source": [
    "class GoogLeNetV3(nn.Module):\n",
    "    def __init__(self, num_classes=2, aux_logits=True, init_weights=False):\n",
    "        super(GoogLeNetV3, self).__init__()\n",
    "        self.aux_logits = aux_logits\n",
    "        \n",
    "        self.conv1 = BasicConv2d(3, 32, kernel_size=3, stride=2)\n",
    "        self.conv2 = BasicConv2d(32, 32, kernel_size=3, stride=1)\n",
    "        self.conv3 = BasicConv2d(32, 64, kernel_size=3, stride=1, padding=1)\n",
    "        self.maxpool1 = nn.MaxPool2d(3, stride=2, ceil_mode=True)\n",
    "\n",
    "        self.conv4 = BasicConv2d(64, 80, kernel_size=1, stride=1)\n",
    "        self.conv5 = BasicConv2d(80, 192, kernel_size=3, stride=1)\n",
    "        self.maxpool2 = nn.MaxPool2d(3, stride=2, ceil_mode=True)\n",
    "        \n",
    "        self.inceptionA1 = InceptionV3_A(in_channels=192, out_channels_1=64, out_channels_2red=48, out_channels_2=64, out_channels_3red=64, out_channels_3=96, out_channels_4=32)\n",
    "        self.inceptionA2 = InceptionV3_A(in_channels=256, out_channels_1=64, out_channels_2red=48, out_channels_2=64, out_channels_3red=64, out_channels_3=96, out_channels_4=64)\n",
    "        self.inceptionA3 = InceptionV3_A(in_channels=288, out_channels_1=64, out_channels_2red=48, out_channels_2=64, out_channels_3red=64, out_channels_3=96, out_channels_4=64)\n",
    "             \n",
    "        self.inceptionD1 = InceptionV3_D(in_channels=288, out_channels_1red=384, out_channels_1=384, out_channels_2red=64, out_channels_2=96)\n",
    "        \n",
    "        self.inceptionB1 = InceptionV3_B(in_channels=768, out_channels_1=192, out_channels_2red=128, out_channels_2=192, out_channels_3red=128, out_channels_3=192, out_channels_4=192)\n",
    "        self.inceptionB2 = InceptionV3_B(in_channels=768, out_channels_1=192, out_channels_2red=160, out_channels_2=192, out_channels_3red=160, out_channels_3=192, out_channels_4=192)\n",
    "        self.inceptionB3 = InceptionV3_B(in_channels=768, out_channels_1=192, out_channels_2red=160, out_channels_2=192, out_channels_3red=160, out_channels_3=192, out_channels_4=192)\n",
    "        self.inceptionB4 = InceptionV3_B(in_channels=768, out_channels_1=192, out_channels_2red=192, out_channels_2=192, out_channels_3red=192, out_channels_3=192, out_channels_4=192)\n",
    "        \n",
    "        if self.aux_logits:\n",
    "            self.aux = InceptionAux(in_channels=768, num_classes=num_classes)\n",
    "        \n",
    "        self.inceptionE1 = InceptionV3_E(in_channels=768, out_channels_1red=192, out_channels_1=320, out_channels_2red=192, out_channels_2=192)\n",
    "        \n",
    "        self.inceptionC1 = InceptionV3_C(in_channels=1280, out_channels_1=320, out_channels_2red=384, out_channels_2=384, out_channels_3red=448, out_channels_3=384, out_channels_4=192)\n",
    "        self.inceptionC2 = InceptionV3_C(in_channels=2048, out_channels_1=320, out_channels_2red=384, out_channels_2=384, out_channels_3red=448, out_channels_3=384, out_channels_4=192)\n",
    "        \n",
    "        self.max_pool3 = nn.MaxPool2d(8, stride=1, ceil_mode=True)\n",
    "        self.dropout = nn.Dropout(p=0.5)\n",
    "        self.fc = nn.Linear(2048, num_classes)\n",
    "        \n",
    "        if init_weights:\n",
    "            self._initialize_weights()\n",
    "\n",
    "    def forward(self, x):\n",
    "        #------ 输入块 ------#\n",
    "        # N x 3 x 224 x 224\n",
    "        x = self.conv1(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.conv3(x)\n",
    "        x = self.maxpool1(x)\n",
    "        x = self.conv4(x)\n",
    "        x = self.conv5(x)\n",
    "        x = self.maxpool2(x)\n",
    "        \n",
    "        #------ Inception ------#\n",
    "        # InceptionAx3\n",
    "        x = self.inceptionA1(x)\n",
    "        x = self.inceptionA2(x)\n",
    "        x = self.inceptionA3(x)\n",
    "        # InceptionDx1\n",
    "        x = self.inceptionD1(x)\n",
    "        # InceptionBx4\n",
    "        x = self.inceptionB1(x)\n",
    "        x = self.inceptionB2(x)\n",
    "        x = self.inceptionB3(x)\n",
    "        x = self.inceptionB4(x)\n",
    "        # InceptionAux\n",
    "        if self.training and self.aux_logits:    # eval model lose this layer\n",
    "            aux = self.aux(x)\n",
    "        # InceptionEx1\n",
    "        x = self.inceptionE1(x)\n",
    "        # InceptionCx1\n",
    "        x = self.inceptionC1(x)\n",
    "        x = self.inceptionC2(x)\n",
    "        \n",
    "        #------ 输出块 ------# \n",
    "        x = self.max_pool3(x)\n",
    "        x = torch.flatten(x, 1)\n",
    "        x = self.dropout(x)\n",
    "        x = self.fc(x)\n",
    "        if self.training and self.aux_logits:   # eval model lose this layer\n",
    "            return x, aux\n",
    "        return x\n",
    "    \n",
    "    def _initialize_weights(self):\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv2d):\n",
    "                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\n",
    "                if m.bias is not None:\n",
    "                    nn.init.constant_(m.bias, 0)\n",
    "            elif isinstance(m, nn.Linear):\n",
    "                nn.init.normal_(m.weight, 0, 0.01)\n",
    "                nn.init.constant_(m.bias, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5808dc22",
   "metadata": {},
   "source": [
    "定义GoogLeNet类的时候，参数num_classes指的是类别的数量，由于我们这里的数据集只有猫和狗两个类别，因此这里的全连接层的神经元个数做了微调。num_classes=2，输出层也是两个神经元，不是原来的1000个神经元。这里的改动大家注意一下，根据实际数据集的类别数量进行调整。整个网络的其它结构跟论文中的完全一样。\n",
    "\n",
    "函数initialize_weights()是对网络参数进行初始化操作，这里我们默认选择关闭初始化操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ab860ef",
   "metadata": {},
   "source": [
    "## 3. 将定义好的网络结构搭载到GPU/CPU，并定义优化器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "7f3ac09a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#创建模型，部署gpu\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "torch.cuda.set_device(1)  # 指定GPU\n",
    "model_name = \"googlenetV3\"\n",
    "model = GoogLeNetV3(num_classes=2, aux_logits=True, init_weights=False)\n",
    "model.to(device)\n",
    "#定义优化器\n",
    "loss_function = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.0004)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "070377c0",
   "metadata": {},
   "source": [
    "## 4. 定义训练过程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "c62c2ed2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_runner(model, device, trainloader, loss_function, optimizer, epoch):\n",
    "    #训练模型, 启用 BatchNormalization 和 Dropout, 将BatchNormalization和Dropout置为True\n",
    "    model.train()\n",
    "    total = 0\n",
    "    correct =0.0\n",
    "    \n",
    "    #enumerate迭代已加载的数据集,同时获取数据和数据下标\n",
    "    for i, data in enumerate(trainloader, 0):\n",
    "        inputs, labels = data\n",
    "        #把模型部署到device上\n",
    "        inputs, labels = inputs.to(device), labels.to(device)\n",
    "        #初始化梯度\n",
    "        optimizer.zero_grad()\n",
    "        #保存训练结果\n",
    "        #outputs = model(inputs)\n",
    "        logits, aux_logits = model(inputs)\n",
    "        #计算损失和\n",
    "        #loss = F.cross_entropy(outputs, labels)\n",
    "        loss0 = loss_function(logits, labels)\n",
    "        loss1 = loss_function(aux_logits, labels)\n",
    "        loss = loss0 + loss1 * 0.3\n",
    "        #获取最大概率的预测结果\n",
    "        #dim=1表示返回每一行的最大值对应的列下标\n",
    "        predict = logits.argmax(dim=1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predict == labels).sum().item()\n",
    "        #反向传播\n",
    "        loss.backward()\n",
    "        #更新参数\n",
    "        optimizer.step()\n",
    "        if i % 100 == 0:\n",
    "            #loss.item()表示当前loss的数值\n",
    "            print(\"Train Epoch{} \\t Loss: {:.6f}, accuracy: {:.6f}%\".format(epoch, loss.item(), 100*(correct/total)))\n",
    "            Loss.append(loss.item())\n",
    "            Accuracy.append(correct/total)\n",
    "    return loss.item(), correct/total"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "100c399d",
   "metadata": {},
   "source": [
    "## 5. 定义测试过程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "2791a40b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_runner(model, device, testloader):\n",
    "    #模型验证, 必须要写, 否则只要有输入数据, 即使不训练, 它也会改变权值\n",
    "    #因为调用eval()将不启用 BatchNormalization 和 Dropout, BatchNormalization和Dropout置为False\n",
    "    model.eval()\n",
    "    #统计模型正确率, 设置初始值\n",
    "    correct = 0.0\n",
    "    test_loss = 0.0\n",
    "    total = 0\n",
    "    #torch.no_grad将不会计算梯度, 也不会进行反向传播\n",
    "    with torch.no_grad():\n",
    "        for data, label in testloader:\n",
    "            data, label = data.to(device), label.to(device)\n",
    "            output = model(data)\n",
    "            test_loss += F.cross_entropy(output, label).item()\n",
    "            predict = output.argmax(dim=1)\n",
    "            #计算正确数量\n",
    "            total += label.size(0)\n",
    "            correct += (predict == label).sum().item()\n",
    "        #计算损失值\n",
    "        print(\"test_avarage_loss: {:.6f}, accuracy: {:.6f}%\".format(test_loss/total, 100*(correct/total)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24558618",
   "metadata": {},
   "source": [
    "## 6. 运行"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "e7e7403b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start_time 2022-03-01 18:05:46\n",
      "Train Epoch1 \t Loss: 1.656523, accuracy: 42.187500%\n",
      "Train Epoch1 \t Loss: 0.921746, accuracy: 57.967203%\n",
      "Train Epoch1 \t Loss: 0.643074, accuracy: 62.733209%\n",
      "Train Epoch1 \t Loss: 0.867303, accuracy: 65.287583%\n",
      "test_avarage_loss: 0.018510, accuracy: 70.460000%\n",
      "end_time:  2022-03-01 18:11:31 \n",
      "\n",
      "start_time 2022-03-01 18:11:31\n",
      "Train Epoch2 \t Loss: 0.672745, accuracy: 73.437500%\n",
      "Train Epoch2 \t Loss: 0.854286, accuracy: 73.220916%\n",
      "Train Epoch2 \t Loss: 0.590059, accuracy: 73.779540%\n",
      "Train Epoch2 \t Loss: 0.569493, accuracy: 74.698920%\n",
      "test_avarage_loss: 0.016145, accuracy: 75.940000%\n",
      "end_time:  2022-03-01 18:17:15 \n",
      "\n",
      "start_time 2022-03-01 18:17:15\n",
      "Train Epoch3 \t Loss: 0.600337, accuracy: 76.562500%\n",
      "Train Epoch3 \t Loss: 0.571187, accuracy: 78.558168%\n",
      "Train Epoch3 \t Loss: 0.422414, accuracy: 78.575871%\n",
      "Train Epoch3 \t Loss: 0.507098, accuracy: 78.301495%\n",
      "test_avarage_loss: 0.015395, accuracy: 75.680000%\n",
      "end_time:  2022-03-01 18:23:00 \n",
      "\n",
      "start_time 2022-03-01 18:23:00\n",
      "Train Epoch4 \t Loss: 0.451280, accuracy: 90.625000%\n",
      "Train Epoch4 \t Loss: 0.494101, accuracy: 82.271040%\n",
      "Train Epoch4 \t Loss: 0.642971, accuracy: 83.527674%\n",
      "Train Epoch4 \t Loss: 0.356568, accuracy: 84.712417%\n",
      "test_avarage_loss: 0.012065, accuracy: 81.520000%\n",
      "end_time:  2022-03-01 18:28:50 \n",
      "\n",
      "start_time 2022-03-01 18:28:50\n",
      "Train Epoch5 \t Loss: 0.401007, accuracy: 82.812500%\n",
      "Train Epoch5 \t Loss: 0.271107, accuracy: 89.449257%\n",
      "Train Epoch5 \t Loss: 0.298375, accuracy: 89.280162%\n",
      "Train Epoch5 \t Loss: 0.159626, accuracy: 89.716570%\n",
      "test_avarage_loss: 0.008430, accuracy: 88.260000%\n",
      "end_time:  2022-03-01 18:34:38 \n",
      "\n",
      "start_time 2022-03-01 18:34:38\n",
      "Train Epoch6 \t Loss: 0.265488, accuracy: 92.187500%\n",
      "Train Epoch6 \t Loss: 0.167884, accuracy: 91.398515%\n",
      "Train Epoch6 \t Loss: 0.252931, accuracy: 91.565609%\n",
      "Train Epoch6 \t Loss: 0.228600, accuracy: 91.663206%\n",
      "test_avarage_loss: 0.008670, accuracy: 87.820000%\n",
      "end_time:  2022-03-01 18:40:21 \n",
      "\n",
      "start_time 2022-03-01 18:40:21\n",
      "Train Epoch7 \t Loss: 0.306576, accuracy: 92.187500%\n",
      "Train Epoch7 \t Loss: 0.118668, accuracy: 93.022896%\n",
      "Train Epoch7 \t Loss: 0.301580, accuracy: 92.863806%\n",
      "Train Epoch7 \t Loss: 0.298711, accuracy: 92.851952%\n",
      "test_avarage_loss: 0.008139, accuracy: 88.700000%\n",
      "end_time:  2022-03-01 18:46:12 \n",
      "\n",
      "start_time 2022-03-01 18:46:12\n",
      "Train Epoch8 \t Loss: 0.166577, accuracy: 96.875000%\n",
      "Train Epoch8 \t Loss: 0.085855, accuracy: 94.446163%\n",
      "Train Epoch8 \t Loss: 0.228471, accuracy: 93.975435%\n",
      "Train Epoch8 \t Loss: 0.093125, accuracy: 93.557932%\n",
      "test_avarage_loss: 0.006280, accuracy: 92.280000%\n",
      "end_time:  2022-03-01 18:52:00 \n",
      "\n",
      "start_time 2022-03-01 18:52:00\n",
      "Train Epoch9 \t Loss: 0.280447, accuracy: 87.500000%\n",
      "Train Epoch9 \t Loss: 0.209730, accuracy: 94.755569%\n",
      "Train Epoch9 \t Loss: 0.124458, accuracy: 94.822761%\n",
      "Train Epoch9 \t Loss: 0.214548, accuracy: 94.606520%\n",
      "test_avarage_loss: 0.022315, accuracy: 69.600000%\n",
      "end_time:  2022-03-01 18:57:47 \n",
      "\n",
      "start_time 2022-03-01 18:57:47\n",
      "Train Epoch10 \t Loss: 0.137481, accuracy: 95.312500%\n",
      "Train Epoch10 \t Loss: 0.096103, accuracy: 94.894802%\n",
      "Train Epoch10 \t Loss: 0.057239, accuracy: 94.978234%\n",
      "Train Epoch10 \t Loss: 0.129888, accuracy: 95.001038%\n",
      "test_avarage_loss: 0.008259, accuracy: 89.920000%\n",
      "end_time:  2022-03-01 19:03:32 \n",
      "\n",
      "start_time 2022-03-01 19:03:32\n",
      "Train Epoch11 \t Loss: 0.205571, accuracy: 93.750000%\n",
      "Train Epoch11 \t Loss: 0.310960, accuracy: 95.745668%\n",
      "Train Epoch11 \t Loss: 0.101669, accuracy: 95.778918%\n",
      "Train Epoch11 \t Loss: 0.163549, accuracy: 95.738164%\n",
      "test_avarage_loss: 0.007507, accuracy: 91.500000%\n",
      "end_time:  2022-03-01 19:09:24 \n",
      "\n",
      "start_time 2022-03-01 19:09:24\n",
      "Train Epoch12 \t Loss: 0.269794, accuracy: 89.062500%\n",
      "Train Epoch12 \t Loss: 0.111179, accuracy: 95.853960%\n",
      "Train Epoch12 \t Loss: 0.333390, accuracy: 95.615672%\n",
      "Train Epoch12 \t Loss: 0.067062, accuracy: 95.852367%\n",
      "test_avarage_loss: 0.004445, accuracy: 94.700000%\n",
      "end_time:  2022-03-01 19:15:20 \n",
      "\n",
      "Finished Training\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAACSCAYAAAC+Pop7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAHJRJREFUeJzt3Xl8VPW9//HXZ7bsISQhbAmEfRNB2VxxV2qv2N5SxaXVW1tta3tta2u1vddb7e/eVrtob+ujrXX9WbQFta21tG6tRQQEgij7kkBCIkJ2yDqZmc/9Yw4xhIQkMDA5w+f5YB7JnDk55/OFyXsO3+/3nCOqijHGmMTiiXcBxhhjYs/C3RhjEpCFuzHGJCALd2OMSUAW7sYYk4As3I0xJgFZuBtjTAKycDeuIyJvikitiCTFuxZj+isLd+MqIlIInA8oMP8k7td3svZlTCxYuBu3+SywCngKuOnQQhFJEZGfiEipiNSLyHIRSXFeO09EVohInYjsEZGbneVvisjnO2zjZhFZ3uG5isjtIrID2OEs+5mzjQMiUiQi53dY3ysi3xGRYhE56LxeICKPiMhPOjZCRP4sIl87EX9BxoCFu3GfzwKLnMcVIjLYWf5jYAZwDpAN3AVERGQE8Ffg58AgYDqwvg/7+wQwB5jsPF/jbCMbeBZYIiLJzmvfAK4DrgQygc8BTcDTwHUi4gEQkVzgEuC5vjTcmL6wcDeuISLnASOBxapaBBQD1zuh+TngDlWtUNWwqq5Q1VbgBuB1VX1OVdtUtVpV+xLuP1DVGlVtBlDV3zrbCKnqT4AkYIKz7ueB/1DVbRr1nrPuaqCeaKADLATeVNV9x/lXYky3LNyNm9wEvKqqVc7zZ51luUAy0bDvrKCb5b21p+MTEblTRLY4XT91wABn/z3t62ngRuf7G4FnjqMmY3pkg0TGFZz+82sAr4h86CxOArKAoUALMAZ4r9OP7gFmd7PZRiC1w/MhXazTftlUp3/920SPwDepakREagHpsK8xwMYutvNbYKOITAMmAX/spiZjYsKO3I1bfAIIE+37nu48JgFvEe2HfwL4qYgMcwY2z3amSi4CLhWRa0TEJyI5IjLd2eZ64F9FJFVExgK39FBDBhACKgGfiNxLtG/9kMeA74vIOIk6XURyAFS1nGh//TPAC4e6eYw5USzcjVvcBDypqmWq+uGhB/ALov3qdwMbiAZoDfAA4FHVMqIDnHc6y9cD05xtPgQEgX1Eu00W9VDDK0QHZ7cDpUT/t9Cx2+anwGLgVeAA8DiQ0uH1p4GpWJeMOQnEbtZhzMkhInOJds8Uqmok3vWYxGZH7sacBCLiB+4AHrNgNyeDhbsxJ5iITALqiA78PhzncswpwrpljDEmAdmRuzHGJCALd2OMSUBxO4kpNzdXCwsL47V7Y4xxpaKioipVHdTTenEL98LCQtauXRuv3RtjjCuJSGlv1rNuGWOMSUAW7sbEWWl1I3VNwXiXYRKMhbsxcbRl7wGueHgZlz+0jDW7a+JdjkkgdlVIY+KkvrmNL/62iMxkP6kBLwsfXcU9H5vILeeNQkR63oA5TOXBVpZu2EtrKEw4AhFVIhElouAR8HoFrwhej+BxvoqAiCCAR4S543PJH5h61P2sK6vlxXXlDEjxMzA1QFZqgOw0Pyl+H/XNbdQ2BaltClLX1EZ9UxthVVRBUZw/fHpGPueMzT3qfo6XhbsxcRCJKHcuXk9FbTO/v+0sxg3O4JuL3+P//WUL68pqeXDBNNKT3PPrWdMYpKi0lrWlNRTvbyAvM5kR2antj+FZKYhAMBwhGIo+2sJKOKJEnPCLqDoP0E5fh2elMCKn69BVVZasLee/l26hvrntuNoxq3AgS754TrevqyrfeXEDxZUNRBTCke5PAk3yeRiQ4sfnkfYP6+iHCVw4ocfJLsfNPe8eYxLIL/9ZzOtb9vO9qyYzY2Q2AL/+zAweXVbCg69sY+uHy7lv/hQmDskkNz1wQo7kVZWv/X49mz84QCiiBEMRQpEIobDi93rISvWTmeInK8VPVqqf1IAvGk4IHiek6praKCqrpaSyEQC/VxiVm0ZRaS21TccXtJ2dOzaHG+aM5LLJg/F7oz3Ku6oa+c6LG1hZUs3swmzu/8QUCgam4hHB44kejXtEiGj0gyQcUcIdjujbP0RQXiiq4IG/bWXN7hpmFWZ3WcOyHVVs/fAgP1pwOgtm5HOgJURdU5CaxiDNwTCZKX6y0wIMTA2QEvDGtP19FbfLD8ycOVNtKqQ5FS3bXslNT65m/rRhPHzt9COCe1VJNV959l2qGloByEjyMXpQGqNy0yjMTWNEdiojc1IpyE5lUHrSMQf/2zuruOGxd5gzKpu8zGT8XsHv8eDzCsFQhPrmNuqao10L9c1tNAZD7d0Kh0IxNeBlekEWMwoHMnNkNqfnDyDZHw21Ay1t7KlpYk9NE+W1zYgIAZ+HJK+HgM+D3+txukhoD2NB8HRYdujDZF1ZLc++U0ZFXTODMpK4dmYBST4PP//HTpJ8Hr5z5SSunVmAx3PsH4LNwTDnPvB3phdk8cTNs7pc57pHV7GrqpFld11EwBefIUsRKVLVmT2uZ+FuzMlTXtvEVT9fTl5GMn+4/RxSA13/57m+uY31e+rYVdlASVUju6oaKals5IP6Zjr+yib7PQzJTG4PNSHah5wW8PKL68+kILv7/uPPP72Gd8vqePvui9sDuT8LR5Rl2ytZ9E4pf9+6n4jClVOH8L2rppCXmdzzBnrh52/s4Cevbeevd5zPpKGZh7323p46rn7kbb575SS+MHd0TPZ3LHob7tYtY0wPmoNh1uyu4e2dVSzfWcXuqkZSAj7Sk7ykJflIS/KRGvBGjzSJdlfAoaPOw23bd5BQWPnVZ2Z0G+wAA1L8XDB+EBeMP7xvtqUtTEVdM2XOEXFZdRP7DrYSOZT4zpfXt+zjode389NrptOV0upG3ti6n69eNNYVwQ7g9QgXTczjool5VNQ1U9MQZGr+gJju47NnF/KrfxbzyzeL+d/rzjjstV8vKyYj2cfC2QUx3eeJYuFuXGf9njre2LKPqcMHMGdUDgNS/THbdmNriJLKRnZWHmTn/gbWldZRVFpLMBzB7xVmjBzINbMKaGkL09AaprE1RENriOqGIIozK6JD10Vnmcl+7ps/hVG5acdUX7Lfy5hB6YwZlH7U9f5n6RYee6uEL184hrF5GUe8/tSK3fg8wo1njTymOuJteFYKw7NSel6xjwak+rnhrJE89lYJd14+npE50X+n3VWN/HXjh3zxgjFkJMfu/XYiWbgb11BVFr1Txn1/3kRbOBqcIjB5aCZnjc5hekEW4YhysDVEQ0uoPXhbQ2Fa2yK0hiLR70OR9lkaEWfKXFiVffUtfFDf0r4/r0cYPziDm84Zybljc5k9KvuoR9v9yRcvGMOiVaU89NoOHrnhzMNeO9jSxpK15Xx86tCYdWckklvOG8VTb+/m0WUl/PcnpwLwm7dK8Hs8/Nu5hfEtrg/c8U41p7yWtjD3/mkji9eWc+GEQTy44HR2VTayqqSGVSXVPLOqlMeX7zrsZzwCaUk+UvxekvweknxeknzRwbxD09M8HvCJB48Ic0bnMDYvnTGD0hibl86I7LS4DZodr+y0ALecN4r//ftOvlRRz2nDP+q+eL6onIbWEDefOyqOFfZfgzOT+dSMfJYUlXPHpeMQhCVF5XxqxnDyMtzzYWjhfgo42NLG5Q8t4z//ZTJXTh0a73L67IO6Zr702yLeK6/nqxeP5WuXjsfrEfIykpkzOoc7GEdLW5hdVY0k+TykJ/vISPKT7Pec0icDfX7uaJ5eWcpPX9vePvsjElGeXrGbM0ZkMb0gK84V9l+3zR3N79eU8fjyXfg9HtrCEb5wfvwGUY+Fhfsp4J2SGvbWt/DE8l1xCffG1hAKpPq9R0xVq29uo7S6kd3VTZRVN9LQGm6fQ+0RQRWeW11GayjCrz8zgyumDOlyH8l+7xGzG051mcl+brtgNA/+bRtFpbXMGDmQN7fvZ3d1E9+4fEK8y+vXCnPTuHLqUBatKsMjcMXkIYzuYZyjv7FwPwWsKK4GYG1pLbuqGo95MO9Y7K5q5IqHl9EaiiAC6QEf6cnR2SU1jcEjTnQJeD0o0TnUh85cnDgkg19cfyZj89z1y9Uf3HxOIU8s382PX9nGc7eexZNv72ZIZjIfO63rD0nzkS9dOIaX398LwG0XuOuoHSzcTwkrS6qZMDiDHfsP8kJROd+84uQdtf3qn8Uo8O15E2kOhj4a7AyGGJgaYGROKiNz0hiZEz1NvasBS1U9pbtXjkdqwMftF43hvj9v5ukVu3lrRxXfumJC+xmepntThg3g41OH0twW5owRA+NdTp9ZuCe42sYgW/Ye4BuXjWddWTIvrCvn65dF+6xPtA/rW3hhXTnXzirgSxeOOebtWLAfn+vnjOA3y0r4r5c2EfB5uG72iHiX5BqdZxq5iX18J7h3dkW7ZM4ek8OCGfnsrW9hRXHVSdn3Y2+VEFG4be6xB7s5fkk+L/9+yTgAPjF9GNlpgThXZE4GO3JPcCuLq0nxe5mWn0VElQEpfp4vKuf8cSf2qnS1jUGeXV3G/GnDjnoKvDk5PjUjn30HWvn0zPx4l2JOEgv3BLeypJqZhQPb52vPnzaMxWv3cKCljcwTeKbdUyt20xQMH1d3jIkdv9fDHZeOi3cZ5iSybpkEVtXQyvZ9DZw9Jqd92YIZ+bSGIvzFmQVwIjS2hnhqxW4unTSY8YOPPPXdGHPi2ZF7AltV4vS3j/4o3E/PH8C4vHSWrN3T64G1PTVNbKyoP+z0/da2CJkpPj55Rv4RZ3E+t7qM+uY2vnyRHbUbEy8W7glsZXE16Uk+pnY49VxEWDAjnx/8dSvFlQ3dXoCqKRjirxs+5PmiclY6HxJdeeytXfzwU1PbbzjRGgrzm7dKOGt0Nme6cPqYMYnCwj2BrSypZlbhQHyd5jR/8ozhPPC3rbxQVM5d8ya2L1dV1pXVsnhNOX/ZsJeG1hAjc1K587LxXDQxj7QkH0k+T/Th97J6VzX/+cdNLPjVSm6cM5K75k3gL+/vZd+BVn60YNrJbq4xpgML9wS170ALJZWNLJx15LWn8zKTuWD8IF5cV8Gdl0+goSXEH94t57nVe9i27yCpAS8fnzqUT88sYFbhwG7nmV88cTBzvp7Dj1/dxlMrdvPa5n14BKYOH8D5407szX+NMUdn4Z6gPupv7zpkPz2zgC8vWsfNT65m9a4aWkMRpuUP4If/OpWrpg0jrZc3Z05L8vFfV03h6unDufuF99n64UHuvWqynXhkTJz16jdYROYBPwO8wGOq+sNOr48AngaynHXuVtWlMa7V9MGKndVkJvuYPKzri2ldMimP3PQk3i2rY8GMfK6bPeKwy8L21fSCLP781fPYsvcAp+fb1QaNibcew11EvMAjwGVAObBGRF5S1c0dVvsPYLGq/lJEJgNLgcITUK/ppZUl1cweldPtZQaSfF5e/fpcknyeXh+l98Tv9ViwG9NP9Gae+2xgp6qWqGoQ+B1wdad1FDh0iDgA+CB2JZq+OnSPzXM6zG/vSnZaIGbBbozpX3rzmz0c2NPheTkwp9M63wNeFZGvAmnApTGpzhyTlcUfXU/GGHNq6s2Re1f/r+9859/rgKdUNR+4EnhGRI7YtojcKiJrRWRtZWVl36s1vbKyuJqBqX4m2NmhxpyyenPkXg50nE+Xz5HdLrcA8wBUdaWIJAO5wP6OK6nqo8CjADNnzjzy1vAGgAMtbeyuaiSi0bnnEQVQfB4POekBctOTSPZ7u/xZVWVVSTVnjc454q5HxphTR2/CfQ0wTkRGARXAQuD6TuuUAZcAT4nIJCAZsEPzPlJV/vBuBd9/efMRdyjqLD3JR056gKzUAF7nlnQeERSloq7ZlXeOMcbETo/hrqohEfkK8ArRaY5PqOomEbkfWKuqLwF3Ar8Rka8T7bK5WVXtyLwPyqqb+O4fN/DWjirOHJHFD+aOJuDzIAgi0csGBEMRahpbqWoIUtXQSnVDkNqmIKpEb00XgYjC3PGDmNfNvUaNMaeGXk2VcOasL+207N4O328Gzo1taaeGUDjC48t38dDr2/F5PNx/9RRunDPSulSMMcfF5sHF0YriKr7/8ha27D3AZZMHc//VUxg6ICXeZRljEoCFexyUVDbwP0u38vqWfQzPSuFXN57JFVOG2Cn7xpiYsXA/ieqagvzsjR08s7KUZL+Xu+ZN4HPnjup25osxxhwrC/cYamkLs7K4mr9v3c+qkmoOtoQIhiO0toUJhiO0hRWPwMLZI/j6peMZlJEU75KNMQnKwv04tLSF2bGvgfV7avnHtkpWFFfR0hYhNeDlrNE55KYHCPg8JPm8BHwekn1erjhtMBOHdH0xL2OMiRUL9278bnUZL66rIDPFz4AUP1mpfrJS/IRV2b7vIFs/PNh+ohHAyJxUFs4awcUT85gzOpskn3W1GGPix8K9C8FQhB+9sg2/18PAtABb9h6grilIYzCMCIzMTmXCkAyuOn0YE4dkMHlYJiOyU21A1BjTb1i4d+G1zfuobgzy5L/N4qIJee3Lg6EIEVUbADXG9HsW7l14bnUZw7NSmDtu0GHLA77eXGfNGGPiz9Kqk7LqJpbvrOLaWQXd3ujCGGP6Owv3Tn63pgyPwKdn5se7FGOMOWYW7h20hSMsXlvOxRPz7DIAxhhXs3Dv4I0t+6lqaGXhrBHxLsUYY46LhXsHz60uY0hmMhdOGNTzysYY049ZuDvKa5tYtqOSa2YV4PPaX4sxxt0sxRyL10TvAX6NDaQaYxKAhTvRG2b8fu0eLhg/iPyBqfEuxxhjjpuFO/Dmtkr2HbCBVGNM4jjlzlB9c9t+tn14kJqmIHWNbdQ2BdlYUc+gjCQumZTX8waMMcYFTplwbwtHuP/Pm3lmVSkAfq8wMDXAwNQABdmpXD9nBH4bSDXGJIhTItyrG1r50qJ1rN5Vw21zR/OVi8eSnuSzqzgaYxJWwof7pg/qufX/F1HV0MrD107nE2cMj3dJxhhzwiV0uP/l/b18c8l7ZKX6WfLFszk9PyveJRljzEmRsOH+9s4qbn92HTNGDuSXN55JXkZyvEsyxpiTplcjiCIyT0S2ichOEbm7m3WuEZHNIrJJRJ6NbZl909ga4tsvvM/o3DQWfX6OBbsx5pTT45G7iHiBR4DLgHJgjYi8pKqbO6wzDrgHOFdVa0UkrnMKH/zbVirqmlly29l21yRjzCmpN0fus4GdqlqiqkHgd8DVndb5AvCIqtYCqOr+2JbZe++UVPP0ylJuPqeQmYXZ8SrDGGPiqjfhPhzY0+F5ubOso/HAeBF5W0RWici8WBXYF83BMHe98D4jslP51hUT4lGCMcb0C70ZUO1qMrh2sZ1xwIVAPvCWiJymqnWHbUjkVuBWgBEjYn+q/09e3UZpdRPPfmEOqYGEHSs2xpge9ebIvRwo6PA8H/igi3X+pKptqroL2EY07A+jqo+q6kxVnTloUGyvmV5UWsvjb+/ihjkjOGdMbky3bYwxbtObcF8DjBORUSISABYCL3Va54/ARQAikku0m6YkloUeTUtbmLuef49hA1K458pJJ2u3xhjTb/UY7qoaAr4CvAJsARar6iYRuV9E5jurvQJUi8hm4B/At1S1+kQV3dnrW/ZRXNnIffOnkJ5k3THGGNOrJFTVpcDSTsvu7fC9At9wHifdhvJ6Al4Pc8fb7fGMMQYS5HruGyrqmTAkg4AvIZpjjDHHzfVpqKpsrKjntOED4l2KMcb0G64P97KaJg60hJhq4W6MMe1cH+4bKuoBLNyNMaaDhAh3v1cYPyQ93qUYY0y/4fpw3+gMpib57AJhxhhziKvDPTqYesC6ZIwxphNXh/uemmbqm9tspowxxnTi6nC3wVRjjOma68Pd7xUmDMmIdynGGNOvuDrcN1bUM36wDaYaY0xnrg13VWVDRb11yRhjTBdcG+7ltTaYaowx3XFtuG+0wVRjjOmWa8N9Q0U9Po8NphpjTFdcHe7jBmeQ7LfBVGOM6cyV4X7oMr9Th2fGuxRjjOmXXBnuFXXN1Da1WX+7McZ0w5Xhfmgw1WbKGGNM11wZ7hsq6vF6hElDrVvGGGO64tJwP8C4vHQbTDXGmG64Ltw/Gky1LhljjOmO68L9g/oWahqDTM23cDfGmO64Ltw3lNtgqjHG9KRX4S4i80Rkm4jsFJG7j7LeAhFREZkZuxIPt33fQbweYbINphpjTLd8Pa0gIl7gEeAyoBxYIyIvqermTutlAP8OvHMiCj3kqxePZeHsAhtMNcaYo+jNkftsYKeqlqhqEPgdcHUX630feBBoiWF9RxAR8jKST+QujDHG9XoT7sOBPR2elzvL2onIGUCBqr4cw9qMMcYco96Eu3SxTNtfFPEADwF39rghkVtFZK2IrK2srOx9lcYYY/qkxz53okfqBR2e5wMfdHieAZwGvCkiAEOAl0Rkvqqu7bghVX0UeBRARCpFpPQY684Fqo7xZ/ujRGpPIrUFrD39WSK1BXrfnpG92Zio6tFXEPEB24FLgApgDXC9qm7qZv03gW92DvZYEpG1qnrCZuScbInUnkRqC1h7+rNEagvEvj09dsuoagj4CvAKsAVYrKqbROR+EZkfq0KMMcbETm+6ZVDVpcDSTsvu7WbdC4+/LGOMMcfDdWeoOh6NdwExlkjtSaS2gLWnP0uktkCM29Njn7sxxhj3ceuRuzHGmKNwXbj39jo3/ZWIPCEi+0VkY4dl2SLymojscL4OjGeNvSUiBSLyDxHZIiKbROQOZ7lb25MsIqtF5D2nPfc5y0eJyDtOe34vIoF419pbIuIVkXdF5GXnuZvbsltENojIehFZ6yxz63stS0SeF5Gtzu/P2bFui6vCvcN1bj4GTAauE5HJ8a2qz54C5nVadjfwhqqOA95wnrtBCLhTVScBZwG3O/8ebm1PK3Cxqk4DpgPzROQs4AHgIac9tcAtcayxr+4gOsvtEDe3BeAiVZ3eYcqgW99rPwP+pqoTgWlE/41i2xZVdc0DOBt4pcPze4B74l3XMbSjENjY4fk2YKjz/VBgW7xrPMZ2/YnoBeZc3x4gFVgHzCF6YonPWX7Ye7A/P4iecPgGcDHwMtGzzV3ZFqfe3UBup2Wue68BmcAunDHPE9UWVx2504vr3LjUYFXdC+B8zYtzPX0mIoXAGUSvCura9jjdGOuB/cBrQDFQp9HzPcBd77mHgbuAiPM8B/e2BaKXPXlVRIpE5FZnmRvfa6OBSuBJp8vsMRFJI8ZtcVu4H/U6NyY+RCQdeAH4mqoeiHc9x0NVw6o6nehR72xgUlerndyq+k5E/gXYr6pFHRd3sWq/b0sH56rqmUS7ZW8XkbnxLugY+YAzgV+q6hlAIyegO8lt4d7TdW7cap+IDAVwvu6Pcz29JiJ+osG+SFVfdBa7tj2HqGod8CbRsYQs5zIc4J733LnAfBHZTfQy3RcTPZJ3Y1sAUNUPnK/7gT8Q/fB143utHChX1UP3vnieaNjHtC1uC/c1wDhnxD8ALAReinNNsfAScJPz/U1E+677PYleKe5xYIuq/rTDS25tzyARyXK+TwEuJTrQ9Q9ggbOaK9qjqveoar6qFhL9Pfm7qt6AC9sCICJpzg2BcLowLgc24sL3mqp+COwRkQnOokuAzcS6LfEeXDiGwYgriV7IrBj4brzrOYb6nwP2Am1EP8FvIdoX+gaww/maHe86e9mW84j+t/59YL3zuNLF7TkdeNdpz0bgXmf5aGA1sBNYAiTFu9Y+tutC4GU3t8Wp+z3nsenQ776L32vTgbXOe+2PwMBYt8XOUDXGmATktm4ZY4wxvWDhbowxCcjC3RhjEpCFuzHGJCALd2OMSUAW7sYYk4As3I0xJgFZuBtjTAL6P8bmeYOrpxgQAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#调用\n",
    "epoch = 12\n",
    "Loss = []\n",
    "Accuracy = []\n",
    "for epoch in range(1, epoch+1):\n",
    "    print(\"start_time\",time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())))\n",
    "    loss, acc = train_runner(model, device, trainloader, loss_function, optimizer, epoch)\n",
    "    Loss.append(loss)\n",
    "    Accuracy.append(acc)\n",
    "    test_runner(model, device, testloader)\n",
    "    print(\"end_time: \",time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())),'\\n')\n",
    "\n",
    "print('Finished Training')\n",
    "plt.subplot(2,1,1)\n",
    "plt.plot(Loss)\n",
    "plt.title('Loss')\n",
    "plt.show()\n",
    "plt.subplot(2,1,2)\n",
    "plt.plot(Accuracy)\n",
    "plt.title('Accuracy')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7e547a7",
   "metadata": {},
   "source": [
    "## 7. 保存模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "4842b660",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GoogLeNetV3(\n",
      "  (conv1): BasicConv2d(\n",
      "    (conv): Conv2d(3, 32, kernel_size=(3, 3), stride=(2, 2))\n",
      "    (relu): ReLU6(inplace=True)\n",
      "  )\n",
      "  (conv2): BasicConv2d(\n",
      "    (conv): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1))\n",
      "    (relu): ReLU6(inplace=True)\n",
      "  )\n",
      "  (conv3): BasicConv2d(\n",
      "    (conv): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (relu): ReLU6(inplace=True)\n",
      "  )\n",
      "  (maxpool1): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=True)\n",
      "  (conv4): BasicConv2d(\n",
      "    (conv): Conv2d(64, 80, kernel_size=(1, 1), stride=(1, 1))\n",
      "    (relu): ReLU6(inplace=True)\n",
      "  )\n",
      "  (conv5): BasicConv2d(\n",
      "    (conv): Conv2d(80, 192, kernel_size=(3, 3), stride=(1, 1))\n",
      "    (relu): ReLU6(inplace=True)\n",
      "  )\n",
      "  (maxpool2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=True)\n",
      "  (inceptionA1): InceptionV3_A(\n",
      "    (branch1): ConvBNReLU(\n",
      "      (conv): Conv2d(192, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(192, 48, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(48, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
      "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(192, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(64, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(96, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(192, 32, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inceptionA2): InceptionV3_A(\n",
      "    (branch1): ConvBNReLU(\n",
      "      (conv): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(256, 48, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(48, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
      "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(64, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(96, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inceptionA3): InceptionV3_A(\n",
      "    (branch1): ConvBNReLU(\n",
      "      (conv): Conv2d(288, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(288, 48, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(48, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
      "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(288, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(64, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(96, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(288, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inceptionD1): InceptionV3_D(\n",
      "    (branch1): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(288, 384, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(384, 384, kernel_size=(3, 3), stride=(2, 2))\n",
      "        (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(288, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(64, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(96, 96, kernel_size=(3, 3), stride=(2, 2))\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  )\n",
      "  (inceptionB1): InceptionV3_B(\n",
      "    (branch1): ConvBNReLU(\n",
      "      (conv): Conv2d(768, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(768, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(128, 128, kernel_size=[1, 7], stride=(1, 1), padding=[0, 3])\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(128, 192, kernel_size=[7, 1], stride=(1, 1), padding=[3, 0])\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(768, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(128, 128, kernel_size=[1, 7], stride=(1, 1), padding=[0, 3])\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(128, 128, kernel_size=[7, 1], stride=(1, 1), padding=[3, 0])\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (3): ConvBNReLU(\n",
      "        (conv): Conv2d(128, 128, kernel_size=[1, 7], stride=(1, 1), padding=[0, 3])\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (4): ConvBNReLU(\n",
      "        (conv): Conv2d(128, 192, kernel_size=[7, 1], stride=(1, 1), padding=[3, 0])\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(768, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inceptionB2): InceptionV3_B(\n",
      "    (branch1): ConvBNReLU(\n",
      "      (conv): Conv2d(768, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(768, 160, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(160, 160, kernel_size=[1, 7], stride=(1, 1), padding=[0, 3])\n",
      "        (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(160, 192, kernel_size=[7, 1], stride=(1, 1), padding=[3, 0])\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(768, 160, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(160, 160, kernel_size=[1, 7], stride=(1, 1), padding=[0, 3])\n",
      "        (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(160, 160, kernel_size=[7, 1], stride=(1, 1), padding=[3, 0])\n",
      "        (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (3): ConvBNReLU(\n",
      "        (conv): Conv2d(160, 160, kernel_size=[1, 7], stride=(1, 1), padding=[0, 3])\n",
      "        (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (4): ConvBNReLU(\n",
      "        (conv): Conv2d(160, 192, kernel_size=[7, 1], stride=(1, 1), padding=[3, 0])\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(768, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inceptionB3): InceptionV3_B(\n",
      "    (branch1): ConvBNReLU(\n",
      "      (conv): Conv2d(768, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(768, 160, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(160, 160, kernel_size=[1, 7], stride=(1, 1), padding=[0, 3])\n",
      "        (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(160, 192, kernel_size=[7, 1], stride=(1, 1), padding=[3, 0])\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(768, 160, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(160, 160, kernel_size=[1, 7], stride=(1, 1), padding=[0, 3])\n",
      "        (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(160, 160, kernel_size=[7, 1], stride=(1, 1), padding=[3, 0])\n",
      "        (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (3): ConvBNReLU(\n",
      "        (conv): Conv2d(160, 160, kernel_size=[1, 7], stride=(1, 1), padding=[0, 3])\n",
      "        (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (4): ConvBNReLU(\n",
      "        (conv): Conv2d(160, 192, kernel_size=[7, 1], stride=(1, 1), padding=[3, 0])\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(768, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inceptionB4): InceptionV3_B(\n",
      "    (branch1): ConvBNReLU(\n",
      "      (conv): Conv2d(768, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(768, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(192, 192, kernel_size=[1, 7], stride=(1, 1), padding=[0, 3])\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(192, 192, kernel_size=[7, 1], stride=(1, 1), padding=[3, 0])\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(768, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(192, 192, kernel_size=[1, 7], stride=(1, 1), padding=[0, 3])\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(192, 192, kernel_size=[7, 1], stride=(1, 1), padding=[3, 0])\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (3): ConvBNReLU(\n",
      "        (conv): Conv2d(192, 192, kernel_size=[1, 7], stride=(1, 1), padding=[0, 3])\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (4): ConvBNReLU(\n",
      "        (conv): Conv2d(192, 192, kernel_size=[7, 1], stride=(1, 1), padding=[3, 0])\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(768, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (aux): InceptionAux(\n",
      "    (averagePool): AvgPool2d(kernel_size=5, stride=3, padding=0)\n",
      "    (conv1): ConvBNReLU(\n",
      "      (conv): Conv2d(768, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (conv2): ConvBNReLU(\n",
      "      (conv): Conv2d(128, 768, kernel_size=(5, 5), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(768, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (fc): Linear(in_features=768, out_features=2, bias=True)\n",
      "  )\n",
      "  (inceptionE1): InceptionV3_E(\n",
      "    (branch1): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(768, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(192, 320, kernel_size=(3, 3), stride=(2, 2))\n",
      "        (bn): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(768, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(192, 192, kernel_size=[1, 7], stride=(1, 1), padding=[0, 3])\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(192, 192, kernel_size=[7, 1], stride=(1, 1), padding=[3, 0])\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (3): ConvBNReLU(\n",
      "        (conv): Conv2d(192, 192, kernel_size=(3, 3), stride=(2, 2))\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  )\n",
      "  (inceptionC1): InceptionV3_C(\n",
      "    (branch1): ConvBNReLU(\n",
      "      (conv): Conv2d(1280, 320, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2_conv1x1): ConvBNReLU(\n",
      "      (conv): Conv2d(1280, 384, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2_conv1x3): ConvBNReLU(\n",
      "      (conv): Conv2d(384, 384, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "      (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2_conv3x1): ConvBNReLU(\n",
      "      (conv): Conv2d(384, 384, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "      (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch3_conv1x1): ConvBNReLU(\n",
      "      (conv): Conv2d(1280, 448, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(448, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch3_conv3x3): ConvBNReLU(\n",
      "      (conv): Conv2d(448, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "      (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch3_conv3x1): ConvBNReLU(\n",
      "      (conv): Conv2d(384, 384, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "      (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch3_conv1x3): ConvBNReLU(\n",
      "      (conv): Conv2d(384, 384, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "      (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(1280, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inceptionC2): InceptionV3_C(\n",
      "    (branch1): ConvBNReLU(\n",
      "      (conv): Conv2d(2048, 320, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2_conv1x1): ConvBNReLU(\n",
      "      (conv): Conv2d(2048, 384, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2_conv1x3): ConvBNReLU(\n",
      "      (conv): Conv2d(384, 384, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "      (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2_conv3x1): ConvBNReLU(\n",
      "      (conv): Conv2d(384, 384, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "      (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch3_conv1x1): ConvBNReLU(\n",
      "      (conv): Conv2d(2048, 448, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(448, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch3_conv3x3): ConvBNReLU(\n",
      "      (conv): Conv2d(448, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "      (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch3_conv3x1): ConvBNReLU(\n",
      "      (conv): Conv2d(384, 384, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "      (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch3_conv1x3): ConvBNReLU(\n",
      "      (conv): Conv2d(384, 384, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "      (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(2048, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (max_pool3): MaxPool2d(kernel_size=8, stride=1, padding=0, dilation=1, ceil_mode=True)\n",
      "  (dropout): Dropout(p=0.5, inplace=False)\n",
      "  (fc): Linear(in_features=2048, out_features=2, bias=True)\n",
      ")\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/jysp/anaconda3/lib/python3.7/site-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type GoogLeNetV3. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "/home/jysp/anaconda3/lib/python3.7/site-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type BasicConv2d. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "/home/jysp/anaconda3/lib/python3.7/site-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type InceptionV3_A. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "/home/jysp/anaconda3/lib/python3.7/site-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type ConvBNReLU. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "/home/jysp/anaconda3/lib/python3.7/site-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type InceptionV3_D. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "/home/jysp/anaconda3/lib/python3.7/site-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type InceptionV3_B. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "/home/jysp/anaconda3/lib/python3.7/site-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type InceptionAux. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "/home/jysp/anaconda3/lib/python3.7/site-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type InceptionV3_E. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "/home/jysp/anaconda3/lib/python3.7/site-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type InceptionV3_C. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    }
   ],
   "source": [
    "print(model)\n",
    "torch.save(model, './models/googlenetv3-catvsdog.pth') #保存模型"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b65f7676",
   "metadata": {},
   "source": [
    "## 8. 模型测试"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a9055d5",
   "metadata": {},
   "source": [
    "下面使用一张猫狗大战测试集的图片进行模型的测试。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "78b81890",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "概率： tensor([[7.7690e-05, 9.9992e-01]], device='cuda:1', grad_fn=<SoftmaxBackward>)\n",
      "预测类别： dog\n"
     ]
    }
   ],
   "source": [
    "from PIL import Image\n",
    "import numpy as np\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "    model = torch.load('./models/googlenetv3-catvsdog.pth') #加载模型\n",
    "    model = model.to(device)\n",
    "    model.eval()    #把模型转为test模式\n",
    "    \n",
    "    #读取要预测的图片\n",
    "    # 读取要预测的图片\n",
    "    img = Image.open(\"./images/test_dog.jpg\") # 读取图像\n",
    "    #img.show()\n",
    "    plt.imshow(img) # 显示图片\n",
    "    plt.axis('off') # 不显示坐标轴\n",
    "    plt.show()\n",
    "    \n",
    "    # 导入图片，图片扩展后为[1，1，32，32]\n",
    "    trans = transforms.Compose(\n",
    "        [\n",
    "            transforms.Resize((299,299)),\n",
    "            transforms.ToTensor(),\n",
    "            transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
    "            #transforms.Normalize(mean = [0.485, 0.456, 0.406],std = [0.229, 0.224, 0.225])\n",
    "        ])\n",
    "    img = trans(img)\n",
    "    img = img.to(device)\n",
    "    img = img.unsqueeze(0)  #图片扩展多一维,因为输入到保存的模型中是4维的[batch_size,通道,长，宽]，而普通图片只有三维，[通道,长，宽]\n",
    "    \n",
    "    # 预测 \n",
    "    # 预测 \n",
    "    classes = ('cat', 'dog')\n",
    "    output = model(img)\n",
    "    prob = F.softmax(output,dim=1) #prob是2个分类的概率\n",
    "    print(\"概率：\",prob)\n",
    "    value, predicted = torch.max(output.data, 1)\n",
    "    predict = output.argmax(dim=1)\n",
    "    pred_class = classes[predicted.item()]\n",
    "    print(\"预测类别：\",pred_class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "035e2e89",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:.conda-pytorch] *",
   "language": "python",
   "name": "conda-env-.conda-pytorch-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
